/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org.me.hello;



import java.applet.Applet;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.net.URL;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;




//librerias para sonido
import java.applet.AudioClip;
import java.awt.*;
import java.awt.event.*;
import javax.swing.JButton;
import javax.swing.JPanel;
import javax.swing.KeyStroke;
import servicios.JugarPartida;



/**
 *
 * @author Ana
 */

public class TestApplet extends Applet implements MouseListener,KeyListener{
    private static int BIG_IMAGE_SIZE = 96;
    private static int SMALL_IMAGE_SIZE = 50;
    private static int SCREEN_WIDTH = 1000;
    private static int SCREEN_HEIGHT = 600;
    
    private Image Minador;
    private Image Barreminas;
    private Image oceanImage;
    private Image proyectilImage;
    private Image flechaImage;
    private int idJugador;
    private boolean turno;
    private boolean partidaEnJuego;
    private int xProy;
    private int yProy;
    private int xProyFinal;
    private int yProyFinal;
    private boolean pasoTurno;
    private boolean lanceProy;
    private int xCrucero;
    private int yCrucero;
    Graphics miCG;
    private Barremina barremina; 
    private Minador minador;
    private Crucero crucero;
    private ArrayList<Isla> islas;
    private ArrayList<Puerto> puertos;
    private boolean clickCuadranteBarremina;
    private boolean clickCuadranteMinador;
    private Image minaImagen;
    private Image minaProfundidadImg;
    private boolean tengoMinasProfundidad;
    private boolean tengoMinasSuperficie;
    Image dobleBuffer;
    private HiloActualizacion hiloActualizacion;
    private HiloProyectil hiloProyectil;
    private HiloSeteadorDeVision hiloSeteadorVision;
    int ancho,lugar,alto;
    //atributos utilizados para el manejo de sonido
    AudioClip sndMarea,sndMinador,sndBarreminas,sndProyectil,sndExplosionMina;

    private boolean veoCrucero,veoMinador,veoBarremina,veoMinasSuperficie,veoMinasProfundidad;
    private enum TipoBarco {MINADOR,BARREMINA};
    
    private int cantidadProyectiles;
    private int cantidadCargasProf;
    private int cantidadMinasDeSuperficie;
    private int cantidadMinasDeProfundidad;
    
    private ArrayList<MinaProfundidad> listaMinasProf;
    private ArrayList<MinaSuperficie> listaMinasSup;
    
    private String textoGanarJuego;
    private String barco;
    /**
     * Initialization method that will be called after the applet is loaded into
     * the browser.
     */
    
    public TestApplet()
    {
        
    }
    
    @Override
    public void init() {
        // TODO start asynchronous download of heavy resources
        this.addMouseListener(this);
        this.addKeyListener(this);
        this.requestFocus();
        
        String id_jugador,turno_jugador;
        if(getParameter("idJugadorParam") != null)
        {
            id_jugador = getParameter("idJugadorParam");
            idJugador = Integer.parseInt(id_jugador);
            turno_jugador = getParameter("turnoParam");
            barco = getParameter("barcoParam");
        }
        else
        {
            String result = jugarPartida("Prueba", 1);
            String cadena []  = result.split(",");
            id_jugador = cadena[0];
            idJugador = Integer.parseInt(id_jugador);
            turno_jugador = cadena[1];
            barco = cadena[2];
        }
        System.out.println("Id jugador en el cliente: " + idJugador);
        
        if(idJugador != -1)
        {
            if(turno_jugador.equals("1"))
            {
                turno = true;
            }
            else
            {
                turno = false;
            }
            System.out.println("Jugador " + idJugador + "Turno: " + turno);
        }
        
        this.setSize(SCREEN_WIDTH, SCREEN_HEIGHT);
        this.setDefaultValues();
        this.partidaEnJuego = false;
        this.xProy = 0;
        this.yProy = 0;
        this.xCrucero = 585;
        this.yCrucero = 584;
        this.xProyFinal = 0;
        this.yProyFinal = 0;
        this.tengoMinasProfundidad = false;
        this.tengoMinasSuperficie = false;
        this.textoGanarJuego = "0";
        
        //seteo de atributos para manejar sonidos
        /*sndMarea= getAudioClip(getCodeBase(), "marea.wav");
        sndMinador=getAudioClip(getCodeBase(), "minador.wav");
        sndBarreminas=getAudioClip(getCodeBase(),"barreminas.wav");
        sndProyectil=getAudioClip(getCodeBase(), "Proyectil.wav");
        sndExplosionMina=getAudioClip(getCodeBase(), "explosionMina.wav");*/
        
        
        //sonidos constantes durante toda la partida
        //sndMarea.loop();
        
        //construir islas y puertos en objeto
        this.islas= new ArrayList<Isla>();
        this.puertos= new ArrayList<Puerto>();    
        
        this.listaMinasProf = new ArrayList<MinaProfundidad>();
        this.listaMinasSup = new ArrayList<MinaSuperficie>();
       
        if(idJugador != -1)
        {
            //traer datos a procesar
            ArrayList<String> estaticos= (ArrayList<String>)getEstaticos();
          
            for (String item : estaticos) 
            {
                //parsear string dentro del item
                String [] ar= item.split(",");
                
                String indice= ar[0];
                
                switch (indice)
                {
                    //analizo si es isla
                    case "I":  
                               //traer id de puerto de isla
                               double d_idIsla= Double.parseDouble(ar[1]);
                               int idIsla= (int)d_idIsla;
                               
                               //traer coordenada x de isla
                               double d_coordX= Double.parseDouble(ar[2]);
                               int coordX= (int)d_coordX;
                               
                               //traer coordenada y de isla
                               double d_coordY= Double.parseDouble(ar[3]);
                               int coordY= (int)d_coordY;
                               
                               //crear Isla con los valores obtenidos
                               Isla isla= new Isla(idIsla, coordX, coordY);
                   
                               //agregar objeto isla a la lista de islas                                                                 
                               islas.add(isla);
                               break;
                        
                    //analizo si es puerto
                    case "P": System.out.println("adentro de P "+indice);
                              //traer id de puerto
                              double d_idPuerto= Double.parseDouble(ar[1]);                              
                              int idPuerto= (int)d_idPuerto;
                              
                              //traer coordenada x de puerto
                              double d_x= Double.parseDouble(ar[2]);
                              int x= (int)d_x;
                              
                              //traer coordenada y de puerto
                              double d_y= Double.parseDouble(ar[3]);
                              int y= (int)d_y;
                              
                              //crear Puerto con los valores obtenidos
                              Puerto puerto= new Puerto(idPuerto, x, y);
                              
                              //agregar objeto puerto a la lista de puertos
                              puertos.add(puerto);
                              break;
                 }
           }
            

            //crearMinador();
            hiloActualizacion = new HiloActualizacion();
            hiloActualizacion.start();
            
            //Hilo del proyectil
            hiloProyectil = new HiloProyectil();
            hiloProyectil.start();
            
            hiloSeteadorVision = new HiloSeteadorDeVision();
            hiloSeteadorVision.start();
      
        }
        
        this.barremina = new Barremina(725, 412,"O");
        this.minador = new Minador(5, 3,"SE");
        this.crucero = new Crucero(855, 46, "S"); 
        
        this.clickCuadranteBarremina = false;
        this.clickCuadranteMinador = false;
        
         ancho = getSize().width;   // o 500 que es el ancho
         alto = getSize().height; 
         lugar = ancho;
         dobleBuffer = createImage(ancho, alto);
         miCG = dobleBuffer.getGraphics();
    }
    
    
    
    public void setDefaultValues() {
        
       //asociar imagen con atributo
        
       //asociar imagen a atributo oceanImage
       URL oceanUrl = getClass().getClassLoader().getResource("images/ocean.jpg");
       oceanImage = getToolkit().getImage(oceanUrl);
       
       URL proyectilUrl = getClass().getClassLoader().getResource("images/proyectil.png");
       proyectilImage = getToolkit().getImage(proyectilUrl);    
       
       URL flechaUrl = getClass().getClassLoader().getResource("images/flecha_N.png");
       flechaImage = getToolkit().getImage(flechaUrl);    
    }
    
    public void paint(Graphics g){
        super.paint(g);
        
        g.drawImage(dobleBuffer,0,0,this );
        
        if(idJugador != -1)
        {               
            Font fuente = new Font("Arial", Font.BOLD, 15);
            g.setFont(fuente);
            //dibujar oceano
            g.drawImage(oceanImage, 0, 0, this);
            //dibujar barremina 
            //Mi barco
             
            if(veoMinasProfundidad)
            {
                for (MinaProfundidad mp : listaMinasProf) {
                    mp.display(g);
                }
            }
            if(veoMinasSuperficie)
            {
                for (MinaSuperficie ms : listaMinasSup) {
                    ms.display(g);
                }
            }    
            //Si soy el barco minador
            if(barco.equals("M")){
                this.minador.display(miCG);
                
                if(veoCrucero)
                {
                    //Solo dibujo lo que veo
                    this.crucero.display(miCG);
                }
                if(veoBarremina)
                {
                    this.barremina.display(miCG);
                }
            }
            if(barco.equals("B"))
            {
                this.barremina.display(miCG);
                
                if(veoCrucero)
                {
                    this.crucero.display(miCG);
                }
                if(veoMinador)
                {
                    this.minador.display(miCG);
                }
            }
                        
           for(Puerto p: this.puertos)
           {
               p.display(g);
           }
           
           for(Isla i: this.islas)
           {
               i.display(g);
           }
            
            //Proyectil
            if(lanceProy) {
                g.setColor(Color.RED);
                g.fillOval(this.xProy, this.yProy,10 , 10);
            }

            if(!textoGanarJuego.matches("0"))
            {
               g.setColor(Color.BLACK);
               g.drawString("Fin del Juego!!!", 450, 260);
               g.drawString(textoGanarJuego, 430, 280);
            }
                            
            if(!textoGanarJuego.matches("0"))
            {
               g.setColor(Color.BLACK);
               g.drawString("Fin del Juego!!!", 450, 260);
               g.drawString(textoGanarJuego, 430, 280);
            }
            
             if(turno)
             {
               g.setColor(Color.GREEN);
               g.drawString("En turno", 450,20);
               g.fillOval(478, 20, 10, 10);
               g.setColor(Color.GREEN);
               
               if(!partidaEnJuego)
               {
                   if(!existePartidaJuego())
                   {
                        g.setColor(Color.WHITE);
                        g.drawString("Esperando un jugador para iniciar la partida", 350, 286);
                   }
                   else
                   {
                       partidaEnJuego = true;
                   }
               }
            }
            else
            {
               g.setColor(Color.red);
                g.fillOval(478, 20, 10, 10);
               g.setColor(Color.RED);
               g.drawString("Fuera de Turno", 440, 20);
            }
        }else {
            g.setFont(new Font("Comic sans MS", Font.BOLD,20));
            g.drawString("Ya existe una partida iniciada", 281, 289);
        }
    }
   
    @Override
     public void update(Graphics g) {
         paint(miCG);
         g.drawImage(dobleBuffer, 0, 0, this);
     }
    @Override
    public void mouseClicked(MouseEvent e) {
        
    }

    @Override
    public void mousePressed(MouseEvent e) {
        //Si es mi turno
        if(turno)
        {
            if(this.barremina.hizoClickEnCuadrante(e.getX(), e.getY())) {
                this.clickCuadranteBarremina = true;
               // System.out.println("Hizo click en Barremina");
                moverBarco(idJugador, e.getX(), e.getY());
            } else {
               // System.out.println("NO Hizo click en Barremina");
                this.clickCuadranteBarremina = false;
            }
            
            if(this.minador.hizoClickEnCuadrante(e.getX(), e.getY())) {
                this.clickCuadranteMinador = true;
                moverBarco(idJugador, e.getX(), e.getY());
            } else {
                this.clickCuadranteMinador = false;
            }
        }  
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        if(this.barremina.hizoClickEnCuadrante(e.getX(), e.getY()))
        {
            //System.out.println("ESTOY EN CUADRANTE BARR");
        } else {
            //System.out.println("NO ESTOY EN CUADRANTE BARR");
        }
        System.out.println("X:  " + e.getX()+  " Y " + e.getY());
    }

    @Override
    public void mouseEntered(MouseEvent e) {

    }

    @Override
    public void mouseExited(MouseEvent e) {

    }

    @Override
    public void keyTyped(KeyEvent e) {
        
    }

    @Override
    public void keyPressed(KeyEvent event) {
        System.out.println("Key pressed!!!!!");
        if(turno)
        {
            switch (event.getKeyCode()) {

                case 10: {// Enter key
                    //pasoTurno = true;
                    pasarTurno();
                    break;}

                case 83: {// s (lanzar mina de superficie)
                    System.out.println("Se ha lanzado mina de superficie...");
                    if(lanzarMinaSuperficie(idJugador)) {
                        System.out.println("SE LANZO MINAS SUP");
                    }else {
                        //Poner mensaje de que no hay mas proyectiles.
                        System.out.println("NO TENGO MAS MINAS SUP");
                    }
                    break;}
                case 80: {// p (lanzar mina de profundidad)
                    System.out.println("Se ha lanzado mina de profundidad...");
                    if(lanzarMinaProfundidad(idJugador)) {
                        System.out.println("SE LANZO MINAS PROF");
                    }else {
                        //Poner mensaje de que no hay mas proyectiles.
                        System.out.println("NO TENGO MAS MINAS PROF");
                    }    
                    break;}
                case 32: {// espacio  
                    if(tengoProyectiles(idJugador)) {

                        ArrayList<String> coordProyectil = (ArrayList<String>) lanzarProyectil(idJugador);
                        System.out.println("Coord proyectil " + coordProyectil);
                        String coordIniciales = coordProyectil.get(0);
                        String coordFinales = coordProyectil.get(1);

                        String [] coordIniParse = coordIniciales.split(",");
                        String [] coordFinParse = coordFinales.split(",");

                        xProy = Integer.parseInt(coordIniParse[0]);
                        yProy = Integer.parseInt(coordIniParse[1]);

                        System.out.println("xProy " + xProy + "yProy " + yProy);

                        xProyFinal = Integer.parseInt(coordFinParse[0]);
                        yProyFinal = Integer.parseInt(coordFinParse[1]);

                        System.out.println("xProyFinal " + xProyFinal + "yProyFinal " + yProyFinal);

                        System.out.println("PROYECTIL");
                        this.lanceProy = true;
                    } else {
                        //Poner mensaje de que no hay mas proyectiles.
                        System.out.println("NO TENGO MAS PROYECTILES");
                    }

                break;}
                case 67: {// c lanzar carga de profundida

                    System.out.println("Se lanza carga de profundidad");
                    if(tengoCargasProfundidad(idJugador)) {
                        boolean eliminoMina = lanzarCargaProfundidad();
                    } else {
                        System.out.println("No tengo cargas de profundidad");
                    }

                    break;}

                case 71:{ //G guardar
                    System.out.println("Guarda la partida");
                    guardarPartida();
                break;}

                case 70: {//F Finalizar
                    //Finalizar aca
                    System.out.println("Finaliza la partida");
                    finalizarPartida();
                break;}
            }             
        }
    }

    @Override
    public void keyReleased(KeyEvent e) {
        
    }
    
    public class HiloActualizacion extends Thread
    {
            public void run()
            {
                // Aquí el código pesado que tarda mucho
                try {
                        while(true){
                                
                                    ArrayList<String> result = (ArrayList<String>)actualizacionDePartida(idJugador);

																for ( Iterator iterador = result.listIterator(); iterador.hasNext(); ) {

                                     String cadena1 = (String) iterador.next();
                                     //Turnos
                                     if(cadena1.length() > 0)
                                     {
                                         //System.out.println(cadena1);
                                         String [] cadena = cadena1.split(",");

                                         if(cadena[0].equals("T"))
                                         {
                                             if(idJugador == Integer.parseInt(cadena[1]))
                                             {
                                                 if(cadena[2].equals("1"))
                                                 {
                                                     turno = true;
                                                 }
                                                 else
                                                 {
                                                     turno = false;
                                                 }      
                                             }
                                         }
                                         //Barcos
                                         if(cadena[0].equals("B"))
                                         {
                                             //Minador
                                             if(cadena[1].equals("1"))
                                             {
                                                 
                                                 int xMinador = Integer.parseInt(cadena[2]);
                                                 int yMinador = Integer.parseInt(cadena[3]);
                                                 String orientacion = cadena[4];
                                                 String barcoHundido = cadena[5];
                                                 int xVision = Integer.parseInt(cadena[6]);
                                                 int yVision = Integer.parseInt(cadena[7]);
                                                 
                                                 if(barcoHundido.equalsIgnoreCase("H"))
                                                 {
                                                     minador.setSeHundioBarco(true);
                                                 } else {
                                                    minador.SetOrientacion(orientacion);
                                                    minador.moverBarco(xMinador, yMinador);
                                                    minador.DibujarRangoVision(xVision, yVision);
                                                    
                                                 }
                                                 
                                                 veoMinador = true;
                                             }
                                             //Barremina
                                             else if(cadena[1].equals("2"))
                                             {
                                                 
                                                 int xBarremina = Integer.parseInt(cadena[2]);
                                                 int yBarremina = Integer.parseInt(cadena[3]);
                                                 String orientacion = cadena[4];
                                                 String barcoHundido = cadena[5];
                                                 int xVision = Integer.parseInt(cadena[6]);
                                                 int yVision = Integer.parseInt(cadena[7]);
                                                 
                                                 if(barcoHundido.equalsIgnoreCase("H"))
                                                 {
                                                     barremina.setSeHundioBarco(true);
                                                 } else {
                                                    barremina.SetOrientacion(orientacion);
                                                    barremina.moverBarco(xBarremina, yBarremina);
                                                    barremina.DibujarRangoVision(xVision, yVision);
                                                    
                                                 }
                                                 
                                                 veoBarremina = true;
                                             }
                                             //Crucero
                                             else if(cadena[1].equals("3"))
                                             {
                                                 
                                                 int x = Integer.parseInt(cadena[2]);
                                                 int y  = Integer.parseInt(cadena[3]);
                                                 String orientacion = cadena[4];
                                                 String barcoHundido = cadena[5];
                                                 if(barcoHundido.equalsIgnoreCase("H"))
                                                 {
                                                     crucero.setSeHundioBarco(true);
                                                 } else {
                                                    crucero.SetOrientacion(orientacion);
                                                    crucero.moverBarco(x, y);
                                                    
                                                 }
                                                 veoCrucero = true;
                                             }
                                         }


                                         //Minas de profundidad
                                         if(cadena[0].equals("MP"))
                                         {
                                             veoMinasProfundidad = true;
                                             int idMinaProfundidad = Integer.parseInt(cadena[1]);
                                             int xMinaProfunidad = Integer.parseInt(cadena[2]);
                                             int yMinaProfundidad = Integer.parseInt(cadena[3]);
                                             boolean fueEliminada = Boolean.parseBoolean(cadena[4]);

                                             MinaProfundidad mp = new MinaProfundidad(idMinaProfundidad, xMinaProfunidad, yMinaProfundidad, fueEliminada);
                                             if(!listaMinasProf.contains(mp)){
                                                 listaMinasProf.add(mp);
                                             }
                                             
                                             actualizarListaMinasProfundidad(mp);
                                             
                                         }                                             
                                          
                                         //Minas de superficie
                                         if(cadena[0].equals("MS"))
                                         {
                                             veoMinasSuperficie = true;
                                             int idMinaSuperficie = Integer.parseInt(cadena[1]);
                                             int xMinaSuperficie = Integer.parseInt(cadena[2]);
                                             int yMinaSuperficie = Integer.parseInt(cadena[3]);
                                             boolean fueEliminada = Boolean.parseBoolean(cadena[4]);
                                             MinaSuperficie ms = new MinaSuperficie(idMinaSuperficie, xMinaSuperficie, yMinaSuperficie, fueEliminada);
                                             if(!listaMinasSup.contains(ms)){
                                                listaMinasSup.add(ms);
                                             }
                                             
                                             actualizarListaMinasSuperficie(ms);
                                             
                                         } 
                                                                                  
                                         //Ganar Juego
                                         if(cadena[0].equals("G"))
                                         {
                                             if(cadena.length > 0) 
                                             {
                                                String gana = cadena[1];
                                                if(!gana.matches("0"))
                                                {
                                                    System.out.println("GANO: " + gana);
                                                    textoGanarJuego = gana;
                                                    repaint();
                                                    hiloActualizacion.stop();
                                                    hiloProyectil.stop();
                                                    hiloSeteadorVision.stop();
                                                }
                                             }
                                         }
                                         
                                         repaint();
                                         Thread.sleep(50); 
                                         
                                     }
                                   }
                        }
                } catch (InterruptedException e) {
              } 
        }
    }
    
    //Hilo del proyectil
    public class HiloProyectil extends Thread
    {
        public void run()
        {
            try {
                while(true){
                    if(lanceProy) {
                        System.out.println("LANCE proyectil");
                        //Muevo el proyectil en la direccion x e y
                        if((xProy < xProyFinal)) {
                            xProy += 2;
                        } else if(xProy > xProyFinal){
                            xProy -= 2;
                        }

                        if(yProy < yProyFinal) {
                            yProy += 2;
                        } else if(yProy > yProyFinal){
                            yProy -= 2;
                        }

                        if((xProy == xProyFinal) && (yProy == yProyFinal)) {
                            lanceProy = false;
                            System.out.println("DETENER proyectil");

                        }
                        repaint();
                        Thread.sleep(100);
                    } 
                }
            } catch (InterruptedException e) {
            } 
        }
    }
    
    public class HiloSeteadorDeVision
    extends Thread
    {
        public void run()
        {
            try {
                while(true){
                    
                        veoBarremina = false;
                        veoMinador = false;
                        veoCrucero = false;
                        veoMinasProfundidad = false;
                        veoMinasSuperficie = false;
                        Thread.sleep(2000);
                     
                }
            } catch (InterruptedException e) {
            } 
        }
    }
    
    public void actualizarListaMinasProfundidad(MinaProfundidad mpActual)
    {        
        for (Iterator<MinaProfundidad> it = listaMinasProf.iterator(); it.hasNext(); ) 
        {
            MinaProfundidad mp = it.next();
            if((mp.getId() == mpActual.getId()) && mpActual.getFueEliminada())
            {
                it.remove();
            }
        } 
    }
    
    public void actualizarListaMinasSuperficie(MinaSuperficie msActual)
    {        
        for (Iterator<MinaSuperficie> it = listaMinasSup.iterator(); it.hasNext(); ) 
        {
            MinaSuperficie ms = it.next();
            if((ms.getId() == msActual.getId()) && msActual.getFueEliminada())
            {
                System.out.println("Elimina mina");
                it.remove();
            }
        } 
    }    
    
    private static boolean consultaTurno(int arg0) {
        return false;
    }

    private static boolean esTurnoJugador(int arg0) {
         return false;
    }

    private static void moviBarco(int arg0) {

    }

    private static boolean seMovieronBarcos() {
        return false;
    }
    
    ///// Metodos auxiliares  //////////////////////////////////////////////////
    private int stringToPosX(String str){
        String [] cadena = str.split(",");
        int posX = Integer.parseInt(cadena[0]);
        return  posX;
    }    
    
       
    private int stringToPosY(String str){
        String [] cadena = str.split(",");
        int posY = Integer.parseInt(cadena[1]);
        return  posY;
    }

    private static void moverBarco(int arg0, int arg1, int arg2) {
        servicios.FachadaService service = new servicios.FachadaService();
        servicios.Fachada port = service.getFachadaPort();
        port.moverBarco(arg0, arg1, arg2);
    }

        //Minas

    private static boolean lanzarMinaProfundidad(int arg0) {
        servicios.FachadaService service = new servicios.FachadaService();
        servicios.Fachada port = service.getFachadaPort();
        return port.lanzarMinaProfundidad(arg0);
    }

    private static boolean lanzarMinaSuperficie(int arg0) {
        servicios.FachadaService service = new servicios.FachadaService();
        servicios.Fachada port = service.getFachadaPort();
        return port.lanzarMinaSuperficie(arg0);
    }
    
    //Proyectil

    private static java.util.List<java.lang.String> lanzarProyectil(int arg0) {
        servicios.FachadaService service = new servicios.FachadaService();
        servicios.Fachada port = service.getFachadaPort();
        return port.lanzarProyectil(arg0);
    }

    private static boolean tengoProyectiles(int arg0) {
        servicios.FachadaService service = new servicios.FachadaService();
        servicios.Fachada port = service.getFachadaPort();
        return port.tengoProyectiles(arg0);
    }

    private static void guardarPartida() {
        servicios.FachadaService service = new servicios.FachadaService();
        servicios.Fachada port = service.getFachadaPort();
        port.guardarPartida();
    }

    private static boolean tengoCargasProfundidad(int arg0) {
        servicios.FachadaService service = new servicios.FachadaService();
        servicios.Fachada port = service.getFachadaPort();
        return port.tengoCargasProfundidad(arg0);
    }

    private static boolean lanzarCargaProfundidad() {
        servicios.FachadaService service = new servicios.FachadaService();
        servicios.Fachada port = service.getFachadaPort();
        return port.lanzarCargaProfundidad();
    }
    
    private static java.util.List<java.lang.String> actualizacionDePartida_1(int arg0) {
        servicios.FachadaService service = new servicios.FachadaService();
        servicios.Fachada port = service.getFachadaPort();
        return port.actualizacionDePartida(arg0);
    }

    private static java.util.List<java.lang.String> actualizacionDePartida(int arg0) {
        servicios.FachadaService service = new servicios.FachadaService();
        servicios.Fachada port = service.getFachadaPort();
        return port.actualizacionDePartida(arg0);
    }

    
    private static String jugarPartida(java.lang.String arg0, int arg1) {
        servicios.FachadaService service = new servicios.FachadaService();
        servicios.Fachada port = service.getFachadaPort();
        return port.jugarPartida(arg0, arg1);
    }

    private static java.util.List<java.lang.String> getEstaticos() {
        servicios.FachadaService service = new servicios.FachadaService();
        servicios.Fachada port = service.getFachadaPort();
        return port.getEstaticos();
    }

    private static boolean existePartidaJuego() {
        servicios.FachadaService service = new servicios.FachadaService();
        servicios.Fachada port = service.getFachadaPort();
        return port.existePartidaJuego();
    }

    private static void pasarTurno() {
        servicios.FachadaService service = new servicios.FachadaService();
        servicios.Fachada port = service.getFachadaPort();
        port.pasarTurno();
    }

    private static void finalizarPartida() {
        servicios.FachadaService service = new servicios.FachadaService();
        servicios.Fachada port = service.getFachadaPort();
        port.finalizarPartida();
    }

}

 
